import asyncio  # used to run async functions
# --- Enums and constants ---
from enum import Enum, auto
from typing import Any, Dict, List, Optional

import pytest  # used for our unit tests
from guardrails.validator_service.async_validator_service import \
    AsyncValidatorService

# ---- Minimal stubs for dependencies ----



class OnFailAction(Enum):
    FIX = auto()
    FIX_REASK = auto()
    CUSTOM = auto()
    REASK = auto()
    EXCEPTION = auto()
    FILTER = auto()
    REFRAIN = auto()
    NOOP = auto()

# --- Result classes ---
class ValidationResult:
    pass

class PassResult(ValidationResult):
    ValueOverrideSentinel = object()
    def __init__(self, value_override=ValueOverrideSentinel):
        self.value_override = value_override

# --- Validator base and logs ---
class Validator:
    def __init__(self, name, on_fail_descriptor=OnFailAction.NOOP, on_fail_method=None, rail_alias=None):
        self.name = name
        self.on_fail_descriptor = on_fail_descriptor
        self.on_fail_method = on_fail_method
        self.rail_alias = rail_alias or name

    async def __call__(self, value, metadata, **kwargs):
        # By default, always pass
        return PassResult()

# --- Iteration and outputs ---
class Outputs:
    def __init__(self):
        self.validator_logs = []

class Iteration:
    def __init__(self, id="iter1"):
        self.id = id
        self.outputs = Outputs()

# --- ValidatorRun ---
class ValidatorRun:
    def __init__(self, value, metadata, on_fail_action, validator_logs):
        self.value = value
        self.metadata = metadata
        self.on_fail_action = on_fail_action
        self.validator_logs = validator_logs

# ---- Test Suite ----

@pytest.fixture
def service():
    # Provide a fresh AsyncValidatorService for each test
    return AsyncValidatorService()

@pytest.fixture
def iteration():
    # Provide a fresh Iteration object for each test
    return Iteration(id="test-iteration")

# --- Basic Test Cases ---

@pytest.mark.asyncio
async def test_async_partial_validate_empty_validator_map(service, iteration):
    """Test with empty validator_map: should return empty list."""
    value = 123
    metadata = {}
    validator_map = {}  # No validators at all
    absolute_path = "foo"
    reference_path = "foo"
    result = await service.async_partial_validate(
        value, metadata, validator_map, iteration, absolute_path, reference_path
    )

@pytest.mark.asyncio
async def test_async_partial_validate_no_validators_for_path(service, iteration):
    """Test with validator_map that has no validators for the reference_path."""
    value = "hello"
    metadata = {"meta": 1}
    validator_map = {"bar": [Validator("dummy")]}  # 'foo' not present
    absolute_path = "foo"
    reference_path = "foo"
    result = await service.async_partial_validate(
        value, metadata, validator_map, iteration, absolute_path, reference_path
    )

@pytest.mark.asyncio



async def test_async_partial_validate_fail_validator_exception(service, iteration):
    """Test with a validator that fails and has on_fail_descriptor=EXCEPTION."""
    class FailingValidator(Validator):
        async def __call__(self, value, metadata, **kwargs):
            return FailResult(error_message="fail-exc", fix_value=None)

    validator = FailingValidator("fail_validator", on_fail_descriptor=OnFailAction.EXCEPTION)
    validator_map = {"foo": [validator]}
    value = "bad"
    metadata = {}
    absolute_path = "foo"
    reference_path = "foo"
    # The perform_correction should raise ValidationError
    with pytest.raises(ValidationError):
        await service.async_partial_validate(
            value, metadata, validator_map, iteration, absolute_path, reference_path
        )

@pytest.mark.asyncio














#------------------------------------------------
import asyncio  # used to run async functions
# Minimal stubs for required classes and enums for testing
from typing import Any, Coroutine, Dict, List, Optional

import pytest  # used for our unit tests
from guardrails.validator_service.async_validator_service import \
    AsyncValidatorService


class OnFailAction:
    FIX = "fix"
    FIX_REASK = "fix_reask"
    CUSTOM = "custom"
    REASK = "reask"
    EXCEPTION = "exception"
    FILTER = "filter"
    REFRAIN = "refrain"
    NOOP = "noop"

class ValidationError(Exception):
    pass

class PassResult:
    ValueOverrideSentinel = object()
    def __init__(self, value_override=ValueOverrideSentinel):
        self.value_override = value_override

class FailResult:
    def __init__(
        self, error_message="fail", fix_value=None, metadata=None
    ):
        self.error_message = error_message
        self.fix_value = fix_value
        self.metadata = metadata

class IterationOutputs:
    def __init__(self):
        self.validator_logs = []

class Iteration:
    def __init__(self, id="iteration_id"):
        self.id = id
        self.outputs = IterationOutputs()

class Validator:
    def __init__(
        self,
        rail_alias="validator",
        on_fail_descriptor=OnFailAction.NOOP,
        on_fail_method=None,
        should_fail=False,
        should_fix=False,
        fix_value=None,
        value_override=None,
        raise_exception=False,
    ):
        self.rail_alias = rail_alias
        self.on_fail_descriptor = on_fail_descriptor
        self.on_fail_method = on_fail_method
        self.should_fail = should_fail
        self.should_fix = should_fix
        self.fix_value = fix_value
        self.value_override = value_override
        self.raise_exception = raise_exception

    # Simulate validation logic
    async def __call__(self, value, metadata, stream, validation_session_id, reference_path, **kwargs):
        if self.raise_exception:
            raise ValidationError("Validator exception")
        if self.should_fail:
            return FailResult(error_message="fail", fix_value=self.fix_value, metadata=metadata)
        if self.value_override is not None:
            result = PassResult(value_override=self.value_override)
            return result
        return PassResult()

# ========== UNIT TESTS ==========

@pytest.mark.asyncio





async def test_async_partial_validate_empty_validator_list():
    """Edge: No validators for reference_path."""
    svc = AsyncValidatorService()
    validator_map = {"root": []}
    iteration = Iteration()
    value = "input"
    metadata = {}
    absolute_path = "root"
    reference_path = "root"
    results = await svc.async_partial_validate(
        value, metadata, validator_map, iteration, absolute_path, reference_path
    )

@pytest.mark.asyncio
async def test_async_partial_validate_unknown_reference_path():
    """Edge: reference_path not in validator_map."""
    svc = AsyncValidatorService()
    validator_map = {"other": []}
    iteration = Iteration()
    value = "input"
    metadata = {}
    absolute_path = "root"
    reference_path = "root"
    results = await svc.async_partial_validate(
        value, metadata, validator_map, iteration, absolute_path, reference_path
    )

@pytest.mark.asyncio